|
| for uncommon there is then often a member function derived classes can overload that describes whether a particular feature is implemented An example is whether an element implements the information necessary to use it in the[2.x.8] finite element | context (see[2.x.9] "hp-finite element support"). **[1.x.2] *Finite element classes have to define a large number of different properties describing a finite element space. The following subsections describe some nomenclature that will be used in the documentation below. *[1.x.3] *[2.x.10] "Vector-valued finite element" are elements used for systems of partial differential equations. Oftentimes |
| |
| for uncommon there is then often a member function derived classes can overload that describes whether a particular feature is implemented An example is whether an element implements the information necessary to use it in the[2.x.8] finite element they are composed via the FESystem class which is itself derived from the current class but there are also non composed elements that have multiple | components (for example the FE_Nedelec and FE_RaviartThomas classes, among others). For any of these vector valued elements |
| |
| it is possible that some of them are in turn constrained leading to longer chains of constraints that the AffineConstraints class will eventually have to sort | out (The constraints described above are used by the[2.x.62] function that constructs an AffineConstraints object.) However |
| |
| one then still needs to cope with the lack of information this just expresses **Return whether this element implements its prolongation matrices for isotropic children The return value also indicates whether a call to the[2.x.177] function will generate an error or not This function is mostly here in order to allow us to write more efficient test programs which we run on all kinds of weird and for which we simply need to exclude certain tests in case something is not implemented It will in general probably not be a great help in since there is not much one can do if one needs these features and they are not implemented This function could be used to check whether a call to< tt > | get_prolongation_matrix ()</tt > will succeed |
| |
| one then still needs to cope with the lack of information this just expresses **Return whether this element implements its restriction matrices The return value also indicates whether a call to the | get_restriction_matrix () function will generate an error or not. Note |
| |
| one then still needs to cope with the lack of information this just expresses **Return whether this element implements its restriction matrices The return value also indicates whether a call to the that this function returns[2.x.178] only if the restriction matrices of the isotropic and all anisotropic refinement cases are implemented If you are interested in the restriction matrices for isotropic refinement use the | isotropic_restriction_is_implemented () function instead. This function is mostly here in order to allow us to write more efficient test programs which we run on all kinds of weird elements |
| |
| one then still needs to cope with the lack of information this just expresses **Access the **Return a read only reference to the matrix that describes the constraints at the interface between a refined and an unrefined cell Some finite elements do | not (yet) implement hanging node const raints. If this is the case |
| |
| one then still needs to cope with the lack of information this just expresses **Access the **Return a read only reference to the matrix that describes the constraints at the interface between a refined and an unrefined cell Some finite elements do then this function will generate an since no useful return value can be generated If you should have a way to live with then you might want to use the | constraints_are_implemented () function to check up front whether this function will succeed or generate the exception. *[0.x.37] *Return whether this element implements its hanging node const raints. The return value also indicates whether a call to the const raints() function will generate an error or not. This function is mostly here in order to allow us to write more efficient test programs which we run on all kinds of weird elements |
| |
| one then still needs to cope with the lack of information this just expresses **Access the **Return a read only reference to the matrix that describes the constraints at the interface between a refined and an unrefined cell Some finite elements do then this function will generate an since no useful return value can be generated If you should have a way to live with then you might want to use the and for which we simply need to exclude certain tests in case hanging node constraints are not implemented It will in general probably not be a great help in since there is not much one can do if one needs hanging node constraints and they are not implemented This function could be used to check whether a call to< tt > | constraints ()</tt > will succeed |
| |
| one then still needs to cope with the lack of information this just expresses **Return whether this element implements its hanging node constraints in the new which has to be used to make elements hp compatible That the element properly implements the get_face_interpolation_matrix and get_subface_interpolation_matrix methods Therefore the return value also indicates whether a call to the | get_face_interpolation_matrix () method and the get_subface_interpolation_matrix() method will generate an error or not. Currently the main purpose of this function is to allow the make_hanging_node_constraints method to decide whether the new procedures |
| |
| one then still needs to cope with the lack of information this just expresses **Return whether this element implements its hanging node constraints in the new which has to be used to make elements hp compatible That the element properly implements the get_face_interpolation_matrix and get_subface_interpolation_matrix methods Therefore the return value also indicates whether a call to the which are supposed to work in the hp framework can be or if the old well verified but not hp capable functions should be used Once the transition to the new scheme for computing the interface constraints is this function will be superfluous and will probably go away Derived classes should implement this function accordingly The default assumption is that a finite element does not provide hp capable face and the default implementation therefore returns *[2.x.179] *Return the matrix interpolating from the given finite element to the present one The size of the matrix is then **Functions to support hp *[2.x.181] *Return the matrix interpolating from a face of one element to the face of the neighboring element The size of the matrix is then< tt > source **Return the matrix interpolating from a face of one element to the subface of the neighboring element The size of the matrix is then< tt > source **Functions to support hp *[2.x.183] on a several finite elements are the hp code first assigns the degrees of freedom of each of these FEs different global indices It then calls this function to find out which of them should get identical and consequently can receive the same global DoF index This function therefore returns a list of identities between DoFs of the present finite element object with the DoFs of[2.x.184] which is a reference to a finite element object representing one of the other finite elements active on this particular vertex The function computes which of the degrees of freedom of the two finite element objects are both numbered between zero and the corresponding value of | n_dofs_per_vertex () of the two finite elements. The first index of each pair denotes one of the vertex dofs of the present element |
| |
| one then still needs to cope with the lack of information this just expresses **Return whether this element implements its hanging node constraints in the new which has to be used to make elements hp compatible That the element properly implements the get_face_interpolation_matrix and get_subface_interpolation_matrix methods Therefore the return value also indicates whether a call to the which are supposed to work in the hp framework can be or if the old well verified but not hp capable functions should be used Once the transition to the new scheme for computing the interface constraints is this function will be superfluous and will probably go away Derived classes should implement this function accordingly The default assumption is that a finite element does not provide hp capable face and the default implementation therefore returns *[2.x.179] *Return the matrix interpolating from the given finite element to the present one The size of the matrix is then **Functions to support hp *[2.x.181] *Return the matrix interpolating from a face of one element to the face of the neighboring element The size of the matrix is then< tt > source **Return the matrix interpolating from a face of one element to the subface of the neighboring element The size of the matrix is then< tt > source **Functions to support hp *[2.x.183] on a several finite elements are the hp code first assigns the degrees of freedom of each of these FEs different global indices It then calls this function to find out which of them should get identical and consequently can receive the same global DoF index This function therefore returns a list of identities between DoFs of the present finite element object with the DoFs of[2.x.184] which is a reference to a finite element object representing one of the other finite elements active on this particular vertex The function computes which of the degrees of freedom of the two finite element objects are both numbered between zero and the corresponding value of whereas the second is the corresponding index of the other finite element **Same as | hp_vertex_dof_indices () |
| |
| one then still needs to cope with the lack of information this just expresses **Return whether this element implements its hanging node constraints in the new which has to be used to make elements hp compatible That the element properly implements the get_face_interpolation_matrix and get_subface_interpolation_matrix methods Therefore the return value also indicates whether a call to the which are supposed to work in the hp framework can be or if the old well verified but not hp capable functions should be used Once the transition to the new scheme for computing the interface constraints is this function will be superfluous and will probably go away Derived classes should implement this function accordingly The default assumption is that a finite element does not provide hp capable face and the default implementation therefore returns *[2.x.179] *Return the matrix interpolating from the given finite element to the present one The size of the matrix is then **Functions to support hp *[2.x.181] *Return the matrix interpolating from a face of one element to the face of the neighboring element The size of the matrix is then< tt > source **Return the matrix interpolating from a face of one element to the subface of the neighboring element The size of the matrix is then< tt > source **Functions to support hp *[2.x.183] on a several finite elements are the hp code first assigns the degrees of freedom of each of these FEs different global indices It then calls this function to find out which of them should get identical and consequently can receive the same global DoF index This function therefore returns a list of identities between DoFs of the present finite element object with the DoFs of[2.x.184] which is a reference to a finite element object representing one of the other finite elements active on this particular vertex The function computes which of the degrees of freedom of the two finite element objects are both numbered between zero and the corresponding value of whereas the second is the corresponding index of the other finite element **Same as except that the function treats degrees of freedom on lines **Same as except that the function treats degrees of freedom on quads **Return whether this element dominates another one given as argument[2.x.185] whether it is the other way whether neither or if either could dominate The[2.x.186] parameter describes the codimension of the investigated subspace and specifies that it is subject to this comparison For if then the elements are compared at i the comparison happens between the function spaces of the two finite elements as restricted to a face Larger values of codim work correspondingly For a definition of see[2.x.187] and in particular the[2.x.188] hp paper **Comparison | operator.The implementation in the current class checks for equality of the following pieces of information between the current object and the one given as argument, in this order:********- the dynamic type (i.e., the type of the most derived class) of the current object and of the given object |
| |
| one then still needs to cope with the lack of information this just expresses **Return whether this element implements its hanging node constraints in the new which has to be used to make elements hp compatible That the element properly implements the get_face_interpolation_matrix and get_subface_interpolation_matrix methods Therefore the return value also indicates whether a call to the which are supposed to work in the hp framework can be or if the old well verified but not hp capable functions should be used Once the transition to the new scheme for computing the interface constraints is this function will be superfluous and will probably go away Derived classes should implement this function accordingly The default assumption is that a finite element does not provide hp capable face and the default implementation therefore returns *[2.x.179] *Return the matrix interpolating from the given finite element to the present one The size of the matrix is then **Functions to support hp *[2.x.181] *Return the matrix interpolating from a face of one element to the face of the neighboring element The size of the matrix is then< tt > source **Return the matrix interpolating from a face of one element to the subface of the neighboring element The size of the matrix is then< tt > source **Functions to support hp *[2.x.183] on a several finite elements are the hp code first assigns the degrees of freedom of each of these FEs different global indices It then calls this function to find out which of them should get identical and consequently can receive the same global DoF index This function therefore returns a list of identities between DoFs of the present finite element object with the DoFs of[2.x.184] which is a reference to a finite element object representing one of the other finite elements active on this particular vertex The function computes which of the degrees of freedom of the two finite element objects are both numbered between zero and the corresponding value of whereas the second is the corresponding index of the other finite element **Same as except that the function treats degrees of freedom on lines **Same as except that the function treats degrees of freedom on quads **Return whether this element dominates another one given as argument[2.x.185] whether it is the other way whether neither or if either could dominate The[2.x.186] parameter describes the codimension of the investigated subspace and specifies that it is subject to this comparison For if then the elements are compared at i the comparison happens between the function spaces of the two finite elements as restricted to a face Larger values of codim work correspondingly For a definition of see[2.x.187] and in particular the[2.x.188] hp paper **Comparison ********the name returned by | get_name () |
| |
| one then still needs to cope with the lack of information this just expresses **Return whether this element implements its hanging node constraints in the new which has to be used to make elements hp compatible That the element properly implements the get_face_interpolation_matrix and get_subface_interpolation_matrix methods Therefore the return value also indicates whether a call to the which are supposed to work in the hp framework can be or if the old well verified but not hp capable functions should be used Once the transition to the new scheme for computing the interface constraints is this function will be superfluous and will probably go away Derived classes should implement this function accordingly The default assumption is that a finite element does not provide hp capable face and the default implementation therefore returns *[2.x.179] *Return the matrix interpolating from the given finite element to the present one The size of the matrix is then **Functions to support hp *[2.x.181] *Return the matrix interpolating from a face of one element to the face of the neighboring element The size of the matrix is then< tt > source **Return the matrix interpolating from a face of one element to the subface of the neighboring element The size of the matrix is then< tt > source **Functions to support hp *[2.x.183] on a several finite elements are the hp code first assigns the degrees of freedom of each of these FEs different global indices It then calls this function to find out which of them should get identical and consequently can receive the same global DoF index This function therefore returns a list of identities between DoFs of the present finite element object with the DoFs of[2.x.184] which is a reference to a finite element object representing one of the other finite elements active on this particular vertex The function computes which of the degrees of freedom of the two finite element objects are both numbered between zero and the corresponding value of whereas the second is the corresponding index of the other finite element **Same as except that the function treats degrees of freedom on lines **Same as except that the function treats degrees of freedom on quads **Return whether this element dominates another one given as argument[2.x.185] whether it is the other way whether neither or if either could dominate The[2.x.186] parameter describes the codimension of the investigated subspace and specifies that it is subject to this comparison For if then the elements are compared at i the comparison happens between the function spaces of the two finite elements as restricted to a face Larger values of codim work correspondingly For a definition of see[2.x.187] and in particular the[2.x.188] hp paper **Comparison ********the name returned by ********as all of the fields in ********constraint matrices This covers most cases where elements can but there are cases of derived elements that are different and for which the current function still returns[2.x.189] For these derived classes should overload this function *This | operator specifically does not check the following member variables of the current class:************- restriction matrices, ************- prolongation matrices of this object and the argument. This is because these member variables may be initialized only on demand by derived classes, rather than being available immediately. Consequently, comparing these members would not only be costly because these are generally big arrays, but also because their computation may be expensive. On the other hand, derived classes for which these arrays may differ for two objects even though the above list compares as equal, will probably want to implement their own operator== () anyway. *[0.x.49] *Non-equality comparison operator.Defined in terms of the equality comparison operator.*[0.x.50] *[2.x.191] Index computations[2.x.192] *[0.x.51] *Compute vector component and index of this shape function within the shape functions corresponding to this component from the index of a shape function within this finite element. If the element is scalar |
| |
| one then still needs to cope with the lack of information this just expresses **Return whether this element implements its hanging node constraints in the new which has to be used to make elements hp compatible That the element properly implements the get_face_interpolation_matrix and get_subface_interpolation_matrix methods Therefore the return value also indicates whether a call to the which are supposed to work in the hp framework can be or if the old well verified but not hp capable functions should be used Once the transition to the new scheme for computing the interface constraints is this function will be superfluous and will probably go away Derived classes should implement this function accordingly The default assumption is that a finite element does not provide hp capable face and the default implementation therefore returns *[2.x.179] *Return the matrix interpolating from the given finite element to the present one The size of the matrix is then **Functions to support hp *[2.x.181] *Return the matrix interpolating from a face of one element to the face of the neighboring element The size of the matrix is then< tt > source **Return the matrix interpolating from a face of one element to the subface of the neighboring element The size of the matrix is then< tt > source **Functions to support hp *[2.x.183] on a several finite elements are the hp code first assigns the degrees of freedom of each of these FEs different global indices It then calls this function to find out which of them should get identical and consequently can receive the same global DoF index This function therefore returns a list of identities between DoFs of the present finite element object with the DoFs of[2.x.184] which is a reference to a finite element object representing one of the other finite elements active on this particular vertex The function computes which of the degrees of freedom of the two finite element objects are both numbered between zero and the corresponding value of whereas the second is the corresponding index of the other finite element **Same as except that the function treats degrees of freedom on lines **Same as except that the function treats degrees of freedom on quads **Return whether this element dominates another one given as argument[2.x.185] whether it is the other way whether neither or if either could dominate The[2.x.186] parameter describes the codimension of the investigated subspace and specifies that it is subject to this comparison For if then the elements are compared at i the comparison happens between the function spaces of the two finite elements as restricted to a face Larger values of codim work correspondingly For a definition of see[2.x.187] and in particular the[2.x.188] hp paper **Comparison ********the name returned by ********as all of the fields in ********constraint matrices This covers most cases where elements can but there are cases of derived elements that are different and for which the current function still returns[2.x.189] For these derived classes should overload this function *This then the component is always and the index within this component is equal to the overall index If the shape function referenced has more than one non zero then it cannot be associated with one vector and an exception of type ExcShapeFunctionNotPrimitive will be raised Note that if the element is composed of | other (base) elements |
| |
| one then still needs to cope with the lack of information this just expresses **Return whether this element implements its hanging node constraints in the new which has to be used to make elements hp compatible That the element properly implements the get_face_interpolation_matrix and get_subface_interpolation_matrix methods Therefore the return value also indicates whether a call to the which are supposed to work in the hp framework can be or if the old well verified but not hp capable functions should be used Once the transition to the new scheme for computing the interface constraints is this function will be superfluous and will probably go away Derived classes should implement this function accordingly The default assumption is that a finite element does not provide hp capable face and the default implementation therefore returns *[2.x.179] *Return the matrix interpolating from the given finite element to the present one The size of the matrix is then **Functions to support hp *[2.x.181] *Return the matrix interpolating from a face of one element to the face of the neighboring element The size of the matrix is then< tt > source **Return the matrix interpolating from a face of one element to the subface of the neighboring element The size of the matrix is then< tt > source **Functions to support hp *[2.x.183] on a several finite elements are the hp code first assigns the degrees of freedom of each of these FEs different global indices It then calls this function to find out which of them should get identical and consequently can receive the same global DoF index This function therefore returns a list of identities between DoFs of the present finite element object with the DoFs of[2.x.184] which is a reference to a finite element object representing one of the other finite elements active on this particular vertex The function computes which of the degrees of freedom of the two finite element objects are both numbered between zero and the corresponding value of whereas the second is the corresponding index of the other finite element **Same as except that the function treats degrees of freedom on lines **Same as except that the function treats degrees of freedom on quads **Return whether this element dominates another one given as argument[2.x.185] whether it is the other way whether neither or if either could dominate The[2.x.186] parameter describes the codimension of the investigated subspace and specifies that it is subject to this comparison For if then the elements are compared at i the comparison happens between the function spaces of the two finite elements as restricted to a face Larger values of codim work correspondingly For a definition of see[2.x.187] and in particular the[2.x.188] hp paper **Comparison ********the name returned by ********as all of the fields in ********constraint matrices This covers most cases where elements can but there are cases of derived elements that are different and for which the current function still returns[2.x.189] For these derived classes should overload this function *This then the component is always and the index within this component is equal to the overall index If the shape function referenced has more than one non zero then it cannot be associated with one vector and an exception of type ExcShapeFunctionNotPrimitive will be raised Note that if the element is composed of and a base element has more than one component but all its shape functions are | primitive (i.e. are non-zero in only one component) |
| |
| one then still needs to cope with the lack of information this just expresses **Return whether this element implements its hanging node constraints in the new which has to be used to make elements hp compatible That the element properly implements the get_face_interpolation_matrix and get_subface_interpolation_matrix methods Therefore the return value also indicates whether a call to the which are supposed to work in the hp framework can be or if the old well verified but not hp capable functions should be used Once the transition to the new scheme for computing the interface constraints is this function will be superfluous and will probably go away Derived classes should implement this function accordingly The default assumption is that a finite element does not provide hp capable face and the default implementation therefore returns *[2.x.179] *Return the matrix interpolating from the given finite element to the present one The size of the matrix is then **Functions to support hp *[2.x.181] *Return the matrix interpolating from a face of one element to the face of the neighboring element The size of the matrix is then< tt > source **Return the matrix interpolating from a face of one element to the subface of the neighboring element The size of the matrix is then< tt > source **Functions to support hp *[2.x.183] on a several finite elements are the hp code first assigns the degrees of freedom of each of these FEs different global indices It then calls this function to find out which of them should get identical and consequently can receive the same global DoF index This function therefore returns a list of identities between DoFs of the present finite element object with the DoFs of[2.x.184] which is a reference to a finite element object representing one of the other finite elements active on this particular vertex The function computes which of the degrees of freedom of the two finite element objects are both numbered between zero and the corresponding value of whereas the second is the corresponding index of the other finite element **Same as except that the function treats degrees of freedom on lines **Same as except that the function treats degrees of freedom on quads **Return whether this element dominates another one given as argument[2.x.185] whether it is the other way whether neither or if either could dominate The[2.x.186] parameter describes the codimension of the investigated subspace and specifies that it is subject to this comparison For if then the elements are compared at i the comparison happens between the function spaces of the two finite elements as restricted to a face Larger values of codim work correspondingly For a definition of see[2.x.187] and in particular the[2.x.188] hp paper **Comparison ********the name returned by ********as all of the fields in ********constraint matrices This covers most cases where elements can but there are cases of derived elements that are different and for which the current function still returns[2.x.189] For these derived classes should overload this function *This then the component is always and the index within this component is equal to the overall index If the shape function referenced has more than one non zero then it cannot be associated with one vector and an exception of type ExcShapeFunctionNotPrimitive will be raised Note that if the element is composed of and a base element has more than one component but all its shape functions are then this mapping contains valid information the index of a shape function of this element within one | component (i.e. the second number of the respective entry of this array) does not indicate the index of the respective shape function within the base element(since that has more than one vector-component). For this information |
| |
| one then still needs to cope with the lack of information this just expresses **Return whether this element implements its hanging node constraints in the new which has to be used to make elements hp compatible That the element properly implements the get_face_interpolation_matrix and get_subface_interpolation_matrix methods Therefore the return value also indicates whether a call to the which are supposed to work in the hp framework can be or if the old well verified but not hp capable functions should be used Once the transition to the new scheme for computing the interface constraints is this function will be superfluous and will probably go away Derived classes should implement this function accordingly The default assumption is that a finite element does not provide hp capable face and the default implementation therefore returns *[2.x.179] *Return the matrix interpolating from the given finite element to the present one The size of the matrix is then **Functions to support hp *[2.x.181] *Return the matrix interpolating from a face of one element to the face of the neighboring element The size of the matrix is then< tt > source **Return the matrix interpolating from a face of one element to the subface of the neighboring element The size of the matrix is then< tt > source **Functions to support hp *[2.x.183] on a several finite elements are the hp code first assigns the degrees of freedom of each of these FEs different global indices It then calls this function to find out which of them should get identical and consequently can receive the same global DoF index This function therefore returns a list of identities between DoFs of the present finite element object with the DoFs of[2.x.184] which is a reference to a finite element object representing one of the other finite elements active on this particular vertex The function computes which of the degrees of freedom of the two finite element objects are both numbered between zero and the corresponding value of whereas the second is the corresponding index of the other finite element **Same as except that the function treats degrees of freedom on lines **Same as except that the function treats degrees of freedom on quads **Return whether this element dominates another one given as argument[2.x.185] whether it is the other way whether neither or if either could dominate The[2.x.186] parameter describes the codimension of the investigated subspace and specifies that it is subject to this comparison For if then the elements are compared at i the comparison happens between the function spaces of the two finite elements as restricted to a face Larger values of codim work correspondingly For a definition of see[2.x.187] and in particular the[2.x.188] hp paper **Comparison ********the name returned by ********as all of the fields in ********constraint matrices This covers most cases where elements can but there are cases of derived elements that are different and for which the current function still returns[2.x.189] For these derived classes should overload this function *This then the component is always and the index within this component is equal to the overall index If the shape function referenced has more than one non zero then it cannot be associated with one vector and an exception of type ExcShapeFunctionNotPrimitive will be raised Note that if the element is composed of and a base element has more than one component but all its shape functions are then this mapping contains valid information the index of a shape function of this element within one refer to the **Compute the shape function for the given vector component and index If the element is then the component must be and the index within this component is equal to the overall index This is the opposite operation from the | system_to_component_index () function. *[0.x.53] *Same as system_to_component_index() |
| |
| one then still needs to cope with the lack of information this just expresses **Return whether this element implements its hanging node constraints in the new which has to be used to make elements hp compatible That the element properly implements the get_face_interpolation_matrix and get_subface_interpolation_matrix methods Therefore the return value also indicates whether a call to the which are supposed to work in the hp framework can be or if the old well verified but not hp capable functions should be used Once the transition to the new scheme for computing the interface constraints is this function will be superfluous and will probably go away Derived classes should implement this function accordingly The default assumption is that a finite element does not provide hp capable face and the default implementation therefore returns *[2.x.179] *Return the matrix interpolating from the given finite element to the present one The size of the matrix is then **Functions to support hp *[2.x.181] *Return the matrix interpolating from a face of one element to the face of the neighboring element The size of the matrix is then< tt > source **Return the matrix interpolating from a face of one element to the subface of the neighboring element The size of the matrix is then< tt > source **Functions to support hp *[2.x.183] on a several finite elements are the hp code first assigns the degrees of freedom of each of these FEs different global indices It then calls this function to find out which of them should get identical and consequently can receive the same global DoF index This function therefore returns a list of identities between DoFs of the present finite element object with the DoFs of[2.x.184] which is a reference to a finite element object representing one of the other finite elements active on this particular vertex The function computes which of the degrees of freedom of the two finite element objects are both numbered between zero and the corresponding value of whereas the second is the corresponding index of the other finite element **Same as except that the function treats degrees of freedom on lines **Same as except that the function treats degrees of freedom on quads **Return whether this element dominates another one given as argument[2.x.185] whether it is the other way whether neither or if either could dominate The[2.x.186] parameter describes the codimension of the investigated subspace and specifies that it is subject to this comparison For if then the elements are compared at i the comparison happens between the function spaces of the two finite elements as restricted to a face Larger values of codim work correspondingly For a definition of see[2.x.187] and in particular the[2.x.188] hp paper **Comparison ********the name returned by ********as all of the fields in ********constraint matrices This covers most cases where elements can but there are cases of derived elements that are different and for which the current function still returns[2.x.189] For these derived classes should overload this function *This then the component is always and the index within this component is equal to the overall index If the shape function referenced has more than one non zero then it cannot be associated with one vector and an exception of type ExcShapeFunctionNotPrimitive will be raised Note that if the element is composed of and a base element has more than one component but all its shape functions are then this mapping contains valid information the index of a shape function of this element within one refer to the **Compute the shape function for the given vector component and index If the element is then the component must be and the index within this component is equal to the overall index This is the opposite operation from the but do it for shape functions and their indices on a face The range of allowed indices is therefore **For faces with non standard face_orientation the dofs on | faces (quads) have to be permuted in order to be combined with the correct shape functions. Given a local dof[2.x.197] on a quad |
| |
| one then still needs to cope with the lack of information this just expresses **Return whether this element implements its hanging node constraints in the new which has to be used to make elements hp compatible That the element properly implements the get_face_interpolation_matrix and get_subface_interpolation_matrix methods Therefore the return value also indicates whether a call to the which are supposed to work in the hp framework can be or if the old well verified but not hp capable functions should be used Once the transition to the new scheme for computing the interface constraints is this function will be superfluous and will probably go away Derived classes should implement this function accordingly The default assumption is that a finite element does not provide hp capable face and the default implementation therefore returns *[2.x.179] *Return the matrix interpolating from the given finite element to the present one The size of the matrix is then **Functions to support hp *[2.x.181] *Return the matrix interpolating from a face of one element to the face of the neighboring element The size of the matrix is then< tt > source **Return the matrix interpolating from a face of one element to the subface of the neighboring element The size of the matrix is then< tt > source **Functions to support hp *[2.x.183] on a several finite elements are the hp code first assigns the degrees of freedom of each of these FEs different global indices It then calls this function to find out which of them should get identical and consequently can receive the same global DoF index This function therefore returns a list of identities between DoFs of the present finite element object with the DoFs of[2.x.184] which is a reference to a finite element object representing one of the other finite elements active on this particular vertex The function computes which of the degrees of freedom of the two finite element objects are both numbered between zero and the corresponding value of whereas the second is the corresponding index of the other finite element **Same as except that the function treats degrees of freedom on lines **Same as except that the function treats degrees of freedom on quads **Return whether this element dominates another one given as argument[2.x.185] whether it is the other way whether neither or if either could dominate The[2.x.186] parameter describes the codimension of the investigated subspace and specifies that it is subject to this comparison For if then the elements are compared at i the comparison happens between the function spaces of the two finite elements as restricted to a face Larger values of codim work correspondingly For a definition of see[2.x.187] and in particular the[2.x.188] hp paper **Comparison ********the name returned by ********as all of the fields in ********constraint matrices This covers most cases where elements can but there are cases of derived elements that are different and for which the current function still returns[2.x.189] For these derived classes should overload this function *This then the component is always and the index within this component is equal to the overall index If the shape function referenced has more than one non zero then it cannot be associated with one vector and an exception of type ExcShapeFunctionNotPrimitive will be raised Note that if the element is composed of and a base element has more than one component but all its shape functions are then this mapping contains valid information the index of a shape function of this element within one refer to the **Compute the shape function for the given vector component and index If the element is then the component must be and the index within this component is equal to the overall index This is the opposite operation from the but do it for shape functions and their indices on a face The range of allowed indices is therefore **For faces with non standard face_orientation the dofs on return the if the face has non standard face_flip or face_rotation In and there is no need for permutation and consequently an exception is thrown **Given an index in the natural ordering of indices on a return the index of the same degree of freedom on the cell To explain the consider the case where we would like to know whether a degree of freedom on a for example as part of an FESystem is primitive the | is_primitive () function in the FiniteElement class takes a cell index |
| |
| one then still needs to cope with the lack of information this just expresses **Return whether this element implements its hanging node constraints in the new which has to be used to make elements hp compatible That the element properly implements the get_face_interpolation_matrix and get_subface_interpolation_matrix methods Therefore the return value also indicates whether a call to the which are supposed to work in the hp framework can be or if the old well verified but not hp capable functions should be used Once the transition to the new scheme for computing the interface constraints is this function will be superfluous and will probably go away Derived classes should implement this function accordingly The default assumption is that a finite element does not provide hp capable face and the default implementation therefore returns *[2.x.179] *Return the matrix interpolating from the given finite element to the present one The size of the matrix is then **Functions to support hp *[2.x.181] *Return the matrix interpolating from a face of one element to the face of the neighboring element The size of the matrix is then< tt > source **Return the matrix interpolating from a face of one element to the subface of the neighboring element The size of the matrix is then< tt > source **Functions to support hp *[2.x.183] on a several finite elements are the hp code first assigns the degrees of freedom of each of these FEs different global indices It then calls this function to find out which of them should get identical and consequently can receive the same global DoF index This function therefore returns a list of identities between DoFs of the present finite element object with the DoFs of[2.x.184] which is a reference to a finite element object representing one of the other finite elements active on this particular vertex The function computes which of the degrees of freedom of the two finite element objects are both numbered between zero and the corresponding value of whereas the second is the corresponding index of the other finite element **Same as except that the function treats degrees of freedom on lines **Same as except that the function treats degrees of freedom on quads **Return whether this element dominates another one given as argument[2.x.185] whether it is the other way whether neither or if either could dominate The[2.x.186] parameter describes the codimension of the investigated subspace and specifies that it is subject to this comparison For if then the elements are compared at i the comparison happens between the function spaces of the two finite elements as restricted to a face Larger values of codim work correspondingly For a definition of see[2.x.187] and in particular the[2.x.188] hp paper **Comparison ********the name returned by ********as all of the fields in ********constraint matrices This covers most cases where elements can but there are cases of derived elements that are different and for which the current function still returns[2.x.189] For these derived classes should overload this function *This then the component is always and the index within this component is equal to the overall index If the shape function referenced has more than one non zero then it cannot be associated with one vector and an exception of type ExcShapeFunctionNotPrimitive will be raised Note that if the element is composed of and a base element has more than one component but all its shape functions are then this mapping contains valid information the index of a shape function of this element within one refer to the **Compute the shape function for the given vector component and index If the element is then the component must be and the index within this component is equal to the overall index This is the opposite operation from the but do it for shape functions and their indices on a face The range of allowed indices is therefore **For faces with non standard face_orientation the dofs on return the if the face has non standard face_flip or face_rotation In and there is no need for permutation and consequently an exception is thrown **Given an index in the natural ordering of indices on a return the index of the same degree of freedom on the cell To explain the consider the case where we would like to know whether a degree of freedom on a for example as part of an FESystem is primitive the so we would need to find the cell index of the shape function that corresponds to the present face index This function does that Code implementing this would then look like or can be etc[2.x.198] face_dof_index The index of the degree of freedom on a face This index must be between zero and dofs_per_face[2.x.199] face The number of the face this degree of freedom lives on This number must be between zero and[2.x.200][2.x.201] face_orientation One part of the description of the orientation of the face See[2.x.202][2.x.203] face_flip One part of the description of the orientation of the face See[2.x.204][2.x.205] face_rotation One part of the description of the orientation of the face See[2.x.206][2.x.207] The index of this degree of freedom within the set of degrees of freedom on the entire cell The returned value will be between zero and dofs_per_cell *This function exists in this class because that is where it was first implemented However it can t really work in the most general case without knowing what element we have The reason is that when a face is flipped or rotated we also need to know whether we need to swap the degrees of freedom on this face or whether they are immune from this For this consider the situation of a[2.x.209] element in If face_flip is then we need to consider the two degrees of freedom on the edge in reverse order On the other if the element were then because the two degrees of freedom on this edge belong to different vector they should not be considered in reverse order What all of this shows is that the function can t work if there are more than one degree of freedom per line or and that in these cases the function will throw an exception pointing out that this functionality will need to be provided by a derived class that knows what degrees of freedom actually represent **For lines with non standard line_orientation the dofs on lines have to be permuted in order to be combined with the correct shape functions Given a dof[2.x.211] on a return the if the line has non standard line_orientation In and there is no need for so the given index is simply returned **Return in which of the vector components of this finite element the[2.x.212] ith shape function is non zero The length of the returned array is equal to the number of vector components of this element For most finite element the result of this function will be a vector with exactly one element being[2.x.213] since for most spaces the individual vector components are independent In that the component with the single zero is also the first element of what for example to make a shape function divergence will there be more than one[2.x.214] entry Elements for which this is true are called non | primitive (see[2.x.215]). *[0.x.58] *Return in how many vector components the[2.x.216] shape function is non- zero. This value equals the number of entries equal to[2.x.217] in the result of the get_nonzero_components() function. For most finite element spaces |
| |
| one then still needs to cope with the lack of information this just expresses **Return whether this element implements its hanging node constraints in the new which has to be used to make elements hp compatible That the element properly implements the get_face_interpolation_matrix and get_subface_interpolation_matrix methods Therefore the return value also indicates whether a call to the which are supposed to work in the hp framework can be or if the old well verified but not hp capable functions should be used Once the transition to the new scheme for computing the interface constraints is this function will be superfluous and will probably go away Derived classes should implement this function accordingly The default assumption is that a finite element does not provide hp capable face and the default implementation therefore returns *[2.x.179] *Return the matrix interpolating from the given finite element to the present one The size of the matrix is then **Functions to support hp *[2.x.181] *Return the matrix interpolating from a face of one element to the face of the neighboring element The size of the matrix is then< tt > source **Return the matrix interpolating from a face of one element to the subface of the neighboring element The size of the matrix is then< tt > source **Functions to support hp *[2.x.183] on a several finite elements are the hp code first assigns the degrees of freedom of each of these FEs different global indices It then calls this function to find out which of them should get identical and consequently can receive the same global DoF index This function therefore returns a list of identities between DoFs of the present finite element object with the DoFs of[2.x.184] which is a reference to a finite element object representing one of the other finite elements active on this particular vertex The function computes which of the degrees of freedom of the two finite element objects are both numbered between zero and the corresponding value of whereas the second is the corresponding index of the other finite element **Same as except that the function treats degrees of freedom on lines **Same as except that the function treats degrees of freedom on quads **Return whether this element dominates another one given as argument[2.x.185] whether it is the other way whether neither or if either could dominate The[2.x.186] parameter describes the codimension of the investigated subspace and specifies that it is subject to this comparison For if then the elements are compared at i the comparison happens between the function spaces of the two finite elements as restricted to a face Larger values of codim work correspondingly For a definition of see[2.x.187] and in particular the[2.x.188] hp paper **Comparison ********the name returned by ********as all of the fields in ********constraint matrices This covers most cases where elements can but there are cases of derived elements that are different and for which the current function still returns[2.x.189] For these derived classes should overload this function *This then the component is always and the index within this component is equal to the overall index If the shape function referenced has more than one non zero then it cannot be associated with one vector and an exception of type ExcShapeFunctionNotPrimitive will be raised Note that if the element is composed of and a base element has more than one component but all its shape functions are then this mapping contains valid information the index of a shape function of this element within one refer to the **Compute the shape function for the given vector component and index If the element is then the component must be and the index within this component is equal to the overall index This is the opposite operation from the but do it for shape functions and their indices on a face The range of allowed indices is therefore **For faces with non standard face_orientation the dofs on return the if the face has non standard face_flip or face_rotation In and there is no need for permutation and consequently an exception is thrown **Given an index in the natural ordering of indices on a return the index of the same degree of freedom on the cell To explain the consider the case where we would like to know whether a degree of freedom on a for example as part of an FESystem is primitive the so we would need to find the cell index of the shape function that corresponds to the present face index This function does that Code implementing this would then look like or can be etc[2.x.198] face_dof_index The index of the degree of freedom on a face This index must be between zero and dofs_per_face[2.x.199] face The number of the face this degree of freedom lives on This number must be between zero and[2.x.200][2.x.201] face_orientation One part of the description of the orientation of the face See[2.x.202][2.x.203] face_flip One part of the description of the orientation of the face See[2.x.204][2.x.205] face_rotation One part of the description of the orientation of the face See[2.x.206][2.x.207] The index of this degree of freedom within the set of degrees of freedom on the entire cell The returned value will be between zero and dofs_per_cell *This function exists in this class because that is where it was first implemented However it can t really work in the most general case without knowing what element we have The reason is that when a face is flipped or rotated we also need to know whether we need to swap the degrees of freedom on this face or whether they are immune from this For this consider the situation of a[2.x.209] element in If face_flip is then we need to consider the two degrees of freedom on the edge in reverse order On the other if the element were then because the two degrees of freedom on this edge belong to different vector they should not be considered in reverse order What all of this shows is that the function can t work if there are more than one degree of freedom per line or and that in these cases the function will throw an exception pointing out that this functionality will need to be provided by a derived class that knows what degrees of freedom actually represent **For lines with non standard line_orientation the dofs on lines have to be permuted in order to be combined with the correct shape functions Given a dof[2.x.211] on a return the if the line has non standard line_orientation In and there is no need for so the given index is simply returned **Return in which of the vector components of this finite element the[2.x.212] ith shape function is non zero The length of the returned array is equal to the number of vector components of this element For most finite element the result of this function will be a vector with exactly one element being[2.x.213] since for most spaces the individual vector components are independent In that the component with the single zero is also the first element of what for example to make a shape function divergence will there be more than one[2.x.214] entry Elements for which this is true are called non the result will be equal to one It is not equal to one only for those ansatz spaces for which vector valued shape functions couple the individual for example in order to make them divergence free **Return whether the entire finite element is in the sense that all its shape functions are primitive If the finite element is then this is always the case Since this is an extremely common the result is cached and returned by this function **Return whether the[2.x.218] shape function is primitive in the sense that the shape function is non zero in only one vector component Non primitive shape functions would for be those of divergence free ansatz in which the individual vector components are coupled The result of the function is[2.x.219] if and only if the result of< tt > | n_nonzero_components (i)</tt > is equal to one. *[0.x.61] *Number of base elements in a mixed discretization. Note that even for vector valued finite elements |
| |
| we cannot already compute the gradients on a concrete cell at the time the current function is but we can at least pre compute the gradients on the reference and store it in the object returned An extensive discussion of the interaction between this function and FEValues can be found in the[2.x.376] documentation module See also the documentation of the InternalDataBase class[2.x.377] update_flags A set of UpdateFlags values that describe what kind of information the FEValues object requests the finite element to compute This set of flags may also include information that the finite element can not e flags that pertain to data produced by the mapping An implementation of this function needs to set up all data fields in the returned object that are necessary to produce the finite element related data specified by these and may already pre compute part of this information as discussed above Elements may want to store these update | flags (or a subset of these flags) in[2.x.378] so they know at the time when[2.x.379] is called what they are supposed to compute[2.x.380] mapping A reference to the mapping used for computing values and derivatives of shape functions.[2.x.381] quadrature A reference to the object that describes where the shape functions should be evaluated.[2.x.382] output_data A reference to the object that FEValues will use in conjunction with the object returned here and where an implementation of[2.x.383] will place the requested information. This allows the current function to already pre-compute pieces of information that can be computed on the reference cell |
| |
| we cannot already compute the gradients on a concrete cell at the time the current function is but we can at least pre compute the gradients on the reference and store it in the object returned An extensive discussion of the interaction between this function and FEValues can be found in the[2.x.376] documentation module See also the documentation of the InternalDataBase class[2.x.377] update_flags A set of UpdateFlags values that describe what kind of information the FEValues object requests the finite element to compute This set of flags may also include information that the finite element can not e flags that pertain to data produced by the mapping An implementation of this function needs to set up all data fields in the returned object that are necessary to produce the finite element related data specified by these and may already pre compute part of this information as discussed above Elements may want to store these update as discussed above FEValues guarantees that this output object and the object returned by the current function will always be used together[2.x.384] A pointer to an object of a type derived from InternalDataBase and that derived classes can use to store scratch data that can be pre or for scratch arrays that then only need to be allocated once The calling site assumes ownership of this object and will delete it when it is no longer necessary **Like | get_data () |
| |
| we cannot already compute the gradients on a concrete cell at the time the current function is but we can at least pre compute the gradients on the reference and store it in the object returned An extensive discussion of the interaction between this function and FEValues can be found in the[2.x.376] documentation module See also the documentation of the InternalDataBase class[2.x.377] update_flags A set of UpdateFlags values that describe what kind of information the FEValues object requests the finite element to compute This set of flags may also include information that the finite element can not e flags that pertain to data produced by the mapping An implementation of this function needs to set up all data fields in the returned object that are necessary to produce the finite element related data specified by these and may already pre compute part of this information as discussed above Elements may want to store these update as discussed above FEValues guarantees that this output object and the object returned by the current function will always be used together[2.x.384] A pointer to an object of a type derived from InternalDataBase and that derived classes can use to store scratch data that can be pre or for scratch arrays that then only need to be allocated once The calling site assumes ownership of this object and will delete it when it is no longer necessary **Like but return an object that will later be used for evaluating shape function information at quadrature points on faces of cells The object will then be used in calls to implementations of[2.x.385] See the documentation of and with that calls the e flags that pertain to data produced by the mapping An implementation of this function needs to set up all data fields in the returned object that are necessary to produce the finite element related data specified by these and may already pre compute part of this information as discussed above Elements may want to store these update as discussed above FEValues guarantees that this output object and the object returned by the current function will always be used together[2.x.393] A pointer to an object of a type derived from InternalDataBase and that derived classes can use to store scratch data that can be pre or for scratch arrays that then only need to be allocated once The calling site assumes ownership of this object and will delete it when it is no longer necessary **Use the version taking a[2.x.395] argument **Like but return an object that will later be used for evaluating shape function information at quadrature points on children of faces of cells The object will then be used in calls to implementations of[2.x.396] See the documentation of and with that calls the e flags that pertain to data produced by the mapping An implementation of this function needs to set up all data fields in the returned object that are necessary to produce the finite element related data specified by these and may already pre compute part of this information as discussed above Elements may want to store these update as discussed above FEValues guarantees that this output object and the object returned by the current function will always be used together[2.x.404] A pointer to an object of a type derived from InternalDataBase and that derived classes can use to store scratch data that can be pre or for scratch arrays that then only need to be allocated once The calling site assumes ownership of this object and will delete it when it is no longer necessary **Compute information about the shape functions on the cell denoted by the first argument Derived classes will have to implement this function based on the kind of element they represent It is called by[2.x.405] this function evaluates shape functions and their derivatives at the quadrature points represented by the mapped locations of those described by the quadrature argument to this function In many computing derivatives of shape | functions (and in some cases also computing values of shape functions) requires making use of the mapping from the reference to the real cell |
| |
| this information can either be taken from the[2.x.406] object that has been filled for the current cell before this function is or by calling the member functions of a Mapping object with the[2.x.407] object that also corresponds to the current cell The information computed by this function is used to fill the various member variables of the output argument of this function Which of the member variables of that structure should be filled is determined by the update flags stored in the[2.x.408] field of the object passed to this function These flags are typically set by[2.x.409][2.x.410] | and (or, more specifically, implementations of these functions in derived classes). An extensive discussion of the interaction between this function and FEValues can be found in the[2.x.412] documentation module.[2.x.413] cell The cell of the triangulation for which this function is to compute a mapping from the reference cell to.[2.x.414] cell_similarity Whether or not the cell given as first argument is simply a translation |
| |
| this information can either be taken from the[2.x.406] object that has been filled for the current cell before this function is or by calling the member functions of a Mapping object with the[2.x.407] object that also corresponds to the current cell The information computed by this function is used to fill the various member variables of the output argument of this function Which of the member variables of that structure should be filled is determined by the update flags stored in the[2.x.408] field of the object passed to this function These flags are typically set by[2.x.409][2.x.410] etc of the cell for which this function was called the most recent time This information is computed simply by matching the | vertices (as stored by the Triangulation) between the previous and the current cell. The value passed here may be modified by implementations of this function and should then be returned(see the discussion of the return value of this function).[2.x.415] quadrature A reference to the quadrature formula in use for the current evaluation. This quadrature object is the same as the one used when creating the[2.x.416] object. The current object is then responsible for evaluating shape functions at the mapped locations of the quadrature points represented by this object.[2.x.417] mapping A reference to the mapping object used to map from the reference cell to the current cell. This object was used to compute the information in the[2.x.418] object before the current function was called. It is also the mapping object that created the[2.x.419] mapping_internal object via[2.x.420] You will need the reference to this mapping object most often to call[2.x.421] to transform gradients and higher derivatives from the reference to the current cell.[2.x.422] mapping_internal An object specific to the mapping object. What the mapping chooses to store in there is of no relevance to the current function |
| |
1.8.17